package com.tankgame;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.util.Vector;

/**
 * @author 周超
 * @version 1.0
 */

//1.先定义一个面板类MyPanel，让其去继承JPanel类，画图形，就在面板上画
//2.KeyListener 是事件监听器接口，可以监听键盘事件，为了监听键盘事件，实现KeyListener
//3.为了让面板不停的重绘子弹，需要把MyPanel做成一个线程，将MyPanel实现 Runnable ,
//  当做一个线程使用，因为子弹是一直走，而且不受我们人为控制的，所以需要不受到人为控制的不停地重新绘制地图
@SuppressWarnings({"all"})
public class MyPanel extends JPanel implements KeyListener, Runnable
{

    /*
    说明:
    1. MyPanel 对象就是一个画板
    2. Graphics g ,把 g 理解成一支画笔
    3. Graphics 提供了很多绘图的方法
    Graphics g
     */

    //以下出现的很多对象，都是在类里面先定义，然后在类MyPanel里面的构造器里面加载

    //定义我的坦克
    Hero hero = null;

    //定义敌人的坦克，放入到 Vector
    Vector<EnemyTank> enemyTanks = new Vector<>();
    //定义一个存放Node对象的Vector，用于接收类Recorder里面保存的集合Vector<Node> nodes，
    //这里面存放未被击中的敌人坦克的坐标和方向信息
    Vector<Node> nodes = new Vector<>();
    //在定义一个 Vector，用于存放我们的炸弹
    Vector<Bomb> bombs = new Vector<>();
    //当一颗子弹击中我方或敌方坦克时，就把类Bomb的对象bomb加入到集合Vector<Bomb> bombs中去

    //定义三张炸弹图片，用于显示爆炸的效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;
    //设置敌人坦克的初始数量为14
    //static int enemyTankSize = 14;



    public MyPanel(String key)
    {
        //先判断我们的记录文件"src\\myRecord.txt"是否存在于目录中
        //如果存在，就正常执行，如果文件不存在，提示，只能开启新游戏，强制让变量key = "1"
        File file = new File(Recorder.getRecordFile());
        if (file.exists())
        {
            nodes = Recorder.getNodesAndEnemyTankRec();//读取文件
        }
        else
        {
            System.out.println("文件不存在，只能开启新的游戏");
            key = "1";
        }
        //初始化自己的坦克
        hero = new Hero(0, 680);
        hero.setDirect(0);//设置我方坦克的原始方向
        hero.setSpeed(5);//设置我方坦克的行动速度


        /*
        这里就分为两种情况，1是新游戏，2是继续上局，那么这里就添加if语句判断选择，
        这里并不是真的继续上局游戏，而是根据选择，是重画所有的敌人坦克还是画上局未被
        击中的敌人坦克,根本不存在所谓的新游戏还是继续上局，每次都是重开一局
         */
        switch (key)
        {
            case "1": //重开游戏
                //重置所有参数为原始数据
                Recorder.setAllEnemyTankNum(0);
                Recorder.score = 0;
                Recorder.enemyTankSize = 14;
                Recorder.heroNum = 1;
                //重新初始化敌人坦克,相当于重新开始一把游戏
                for (int i = 0; i < Recorder.enemyTankSize; i++)
                {
                    //设置敌人的坦克
                    EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
                    //每当创建一个敌人坦克对象enemyTank，就让对象enemyTank拥有Vector<EnemyTank> enemyTanks集合，
                    //以防止敌人坦克的碰撞
                    enemyTank.setEnemyTanks(enemyTanks);//牛逼
                    //设置敌人的坦克的初始方向是——>向下
                    enemyTank.setDirect(2);
                    //设置敌人坦克的速度
                    enemyTank.setSpeed(4);
                    //把创建好的坦克对象 enemyTank加入到类 MyPanel的字段 Vector<EnemyTank> enemyTanks中
                    enemyTanks.add(enemyTank);
                    //在创建敌人坦克对象的地方，启动敌人坦克线程，让敌人坦克随意动起来
                    new Thread(enemyTank).start();
                    //给enemyTank对象加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60,
                            enemyTank.getDirect());

                    //把创建好的子弹对象 shot加入到类 EnemyTank的字段 Vector<Shot> shots中
                    enemyTank.shots.add(shot);
                    //启动线程 shot，让子弹的横纵坐标可以进行移动
                    new Thread(shot).start();
                }
                break;

            case "2":  //继续上局游戏，下午来了重新看一遍
                Recorder.heroNum = 1;
                for (int i = 0; i < nodes.size(); i++)
                {
                    Node node = nodes.get(i);
                    //设置敌人的坦克
                    EnemyTank enemyTank = new EnemyTank(node.getX(), node.getY());
                    //每当创建一个敌人坦克对象enemyTank，就让对象enemyTank拥有Vector<EnemyTank> enemyTanks集合，
                    //以防止敌人坦克的碰撞
                    enemyTank.setEnemyTanks(enemyTanks);//牛逼
                    //设置上局游戏敌人的坦克的方向
                    enemyTank.setDirect(node.getDirect());
                    //设置敌人坦克的速度
                    enemyTank.setSpeed(4);
                    //把创建好的坦克对象 enemyTank加入到类 MyPanel的字段 Vector<EnemyTank> enemyTanks中
                    enemyTanks.add(enemyTank);
                    //在创建敌人坦克对象的地方，启动敌人坦克线程，让敌人坦克随意动起来
                    new Thread(enemyTank).start();
                    //给enemyTank对象加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60,
                            enemyTank.getDirect());

                    //把创建好的子弹对象 shot加入到类 EnemyTank的字段 Vector<Shot> shots中
                    enemyTank.shots.add(shot);
                    //启动线程 shot，让子弹的横纵坐标可以进行移动
                    new Thread(shot).start();

                }
                break;
            default:
                System.out.println("你的输入有误");
        }

        //防止我方坦克碰撞敌人坦克
        //让我方坦克hero得到所有的敌人坦克，也就是敌人坦克集合
        hero.setEnemyTanks(enemyTanks);

        //将MyPanel对象的 enemyTanks 设置给 Recorder 的 enemyTanks
        Recorder.setEnemyTanks(enemyTanks);
        String path1 = new File("resources/bomb_1.gif").getAbsolutePath();
        String path2 = new File("resources/bomb_2.gif").getAbsolutePath();
        String path3 = new File("resources/bomb_3.gif").getAbsolutePath();
        //初始化图片对象
//        image1 = Toolkit.getDefaultToolkit().
//                getImage(Panel.class.getResource(path1));
//        image2 = Toolkit.getDefaultToolkit().
//                getImage(Panel.class.getResource(path2));
//        image3 = Toolkit.getDefaultToolkit().
//                getImage(Panel.class.getResource(path3));
        image1 = Toolkit.getDefaultToolkit().
                getImage(path1);
        image2 = Toolkit.getDefaultToolkit().
                getImage(path2);
        image3 = Toolkit.getDefaultToolkit().
                getImage(path3);
        //在这里，播放指定的背景音乐
        new AePlayWave("src\\111.wav").start();
    }


    //编写方法，显示我方击毁敌方坦克的数量信息
    public void showInfo(Graphics g) //传入画笔
    {
        //画出玩家的总成绩
        //画笔颜色,黑色
        g.setColor(Color.BLACK);
        //设置字体
        Font font = new Font("宋体", Font.BOLD, 30);
        //把字体设置给画笔
        g.setFont(font);
        //写字
        g.drawString("累积击毁的坦克数量：",1510,200);
        g.drawString("累积得分：",1510,440);
        g.drawString("敌我双方坦克数量：",1510,600);
        g.drawString("我方(黄色)VS敌方(青色)",1510,650);
        //画出一个敌方坦克
        drawTank(1510,230,g,0,0);
        //再分别画出一个我方坦克和敌方坦克
        drawTank(1510,700,g,0,1);//我方
        drawTank(1510,800,g,0,0);//敌方

        //再次设置颜色,黑色
        g.setColor(Color.BLACK);
        g.drawString( Recorder.getAllEnemyTankNum()+ "",1570,260);
        g.setColor(Color.RED);
        g.drawString( Recorder.score+ "",1660,440);//记录当前分数
        g.drawString( Recorder.enemyTankSize+ "",1600,840);//记录存活的敌人坦克数量
        g.drawString( Recorder.heroNum+ "",1600,740);//记录我方坦克存活数量
        g.setColor(Color.BLACK);
    }

    @Override
    public void paint(Graphics g) //传入画笔
    {
        super.paint(g);//保留父类绘制逻辑的同时,添加自己的绘制效果。
                       //页面重置一下，去除那些多余的图像内容，然后再对图像进行绘制。
        g.fillRect(0, 0, 1500, 1250);//填充矩形，默认为黑色

        //调用显示玩家信息的方法
        showInfo(g);
        /*
        开始画出我方坦克，我们把它封装成一个方法。在画我的坦克之前进行判断，
        我的坦克是否被击中，没有被击中就一直画，击中后就不会画出来
         */
        if (hero != null && hero.isLive == true)
        {
            drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 1);
        }

        //绘制我方发射的子弹：先保证发射的子弹不等于null，而且存活状态是true，然后再画出hero射击发出的子弹
//        if (hero.shot != null && hero.shot.isLive == true)
//        {
//            /**画出来的子弹是如何一直移动的？（我方和敌方的子弹移动原理一样）
//             * MyPanel线程一旦启动，里面的run()方法有this.repaint()方法，而且是无限循环，
//             * 会不停的重新绘制图像，也就是不停地重新绘制子弹，至于子弹的移动，子弹的线程run()
//             * 方法不停的改变子弹的x，y坐标，而在paint();方法中画子弹的语句不断的被执行，
//             * 所以造成了子弹移动画面
//             */
//            g.fill3DRect(hero.shot.x, hero.shot.y, 7, 7, false);
//        }

        //让我方坦克可以发射多颗子弹：
        //将hero的子弹集合shots 遍历取出，然后绘制
        for (int i = 0; i < hero.shots.size(); i++)
        {
            //先从我方坦克中取出子弹
            Shot shot = hero.shots.get(i);
            //绘制我方发射的子弹：先保证发射的子弹不等于null，而且存活状态是true，然后再画出hero射击发出的子弹
            if (shot != null && shot.isLive == true)
            {
                /**
                 * 画出来的子弹是如何一直移动的？（我方和敌方的子弹移动原理一样）
                 * MyPanel线程一旦启动，里面的run()方法有this.repaint()方法，而且是无限循环，
                 * 会不停的重新绘制图像，也就是不停地重新绘制子弹，至于子弹的移动，子弹的线程run()
                 * 方法不停的改变子弹的x，y坐标，而在paint()方法中画子弹的语句不断的被执行，
                 * 所以造成了子弹移动画面
                 */
                g.fill3DRect(shot.x, shot.y, 6, 6, false);
            }
            else //如果该shot对象已经无效 ,就从shots集合中拿掉，那么为什么必须要去除掉这个无效的shot对象呢？
                 //因为如果不去除掉的话，上面的遍历程序会再次把这个无效的子弹画出来
            {
                hero.shots.remove(shot);
            }
        }

        //开始画出敌方坦克，遍历 Vector
        for (int i = 0; i < enemyTanks.size(); i++)
        {
            //从集合Vector中，取出坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            /**
             * 解释为什么要有 if (enemyTank.isLive == true) 这条语句？
             *
             * 答：如果敌人坦克已经被击中了，那么在 hitTank()方法里面，是会将enemyTank.isLive的
             * 状态改变为false，一旦置为 false，那么就不会进入到这里的if()语句，那就不会画出此时此刻
             * 的敌人坦克，就相当于消失了
             */
            //判断当前的敌人坦克是否还存活，如果是活着的：true，我们才把它画出来,因为
            //在判断if语句之前，可能已经有我方子弹把敌人坦克给摧毁掉了
            if (enemyTank.isLive == true)
            {
                drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 0);
                //遍历enemyTank的所有子弹，同时画出来
                for (int j = 0; j < enemyTank.shots.size(); j++)
                {
                    //先取出当前enemyTank对象的第一颗子弹，后续遍历会全部取出
                    Shot shot = enemyTank.shots.get(j);
                    //绘制敌人的子弹,要有判断是否一直绘制敌人坦克子弹，如果为false的话，就停止绘制
                    if (shot.isLive == true)
                    {
                        g.fill3DRect(shot.x, shot.y, 6, 6, false);
                    }
                    else
                    {
                        //如果为false，就把这颗子弹从Vector中移除，不移除，则敌人子弹会一直绘制
                        enemyTank.shots.remove(shot);
                    }
                }
            }
            /*
            //不为true，就为false，说明坦克已经被击中死亡，所以从集合enemyTanks中移除
            else
            {
                enemyTanks.remove(enemyTank);
            }
             */
        }

        //当有坦克被击中时（无论是我方还是敌方）,才会创建对象bomb,然后加入到集合Vector<Bomb> bombs中，
        //如果集合bombs中有元素对象bomb的话，就得画出来
        for (int i = 0; i < bombs.size(); i++)
        {
            //先从集合对象中取出炸弹对象bomb
            Bomb bomb = bombs.get(i);
            //再根据当前的bomb对象的生命值life，去画出对应的爆炸效果渐变的图片
            if (bomb.life > 6)
            {
                g.drawImage(image1, bomb.x - 8, bomb.y - 8, 80,80,this);
            }
            else if (bomb.life > 3)
            {
                g.drawImage(image2, bomb.x - 8, bomb.y - 8, 80,80,this);
            }
            else
            {
                g.drawImage(image3, bomb.x - 8, bomb.y - 8, 80,80,this);
            }
            //上面的if语句只是画了一次爆炸效果，所以让爆炸的生命值进行减少，让爆炸有渐变的切换，
            //从而达到真实的效果
            bomb.lifeDown();
            //如果爆炸bomb的生命值life减少到0，就从集合bombs中移除
            if (bomb.life == 0)
            {
                bombs.remove(bomb);
            }

        }


    }

    /**
     *
     * @param x 坦克左上角x坐标
     * @param y 坦克左上角y坐标
     * @param g 画笔
     * @param direct 坦克方向（上下左右）
     * @param type 坦克类型（我方，敌方）
     */
    public void drawTank(int x, int y, Graphics g, int direct ,int type)
    {
        //给不同类型的坦克，设置不同的颜色
        switch (type)
        {
            case 0:  //0代表敌方坦克
                g.setColor(Color.cyan);
                break;
            case 1:  //1代表我方坦克
                g.setColor(Color.yellow);
                break;
        }

        //根据坦克方向，来绘制对应形状坦克
        //direct 表示方向(0向上  1向右  2向下  3向左)
        switch (direct)
        {
            case 0:  //向上的方向
                g.fill3DRect(x,y,10,60,false);//画出坦克左边的轮子
                g.fill3DRect(x + 30,y,10,60,false);//坦克右边的轮子
                g.fill3DRect(x + 10,y + 10,20,40,false);//坦克主体
                g.fillOval(x + 10,y + 20,20,20);//坦克上面圆盖
                g.drawLine(x + 20, y + 30, x + 20, y );//坦克炮筒
                break;

            case 1:  //向右的方向
                g.fill3DRect(x, y, 60, 10, false);//画出坦克上边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边轮子
                g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克盖子
                g.fillOval(x + 20, y + 10, 20, 20);//画出圆形盖子
                g.drawLine(x + 30, y + 20, x + 60, y + 20);//画出炮筒
                break;

            case 2: //表示向下
                g.fill3DRect(x, y, 10, 60, false);//画出坦克左边轮子
                g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边轮子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克盖子
                g.fillOval(x + 10, y + 20, 20, 20);//画出圆形盖子
                g.drawLine(x + 20, y + 30, x + 20, y + 60);//画出炮筒
                break;

            case 3: //表示向左
                g.fill3DRect(x, y, 60, 10, false);//画出坦克上边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边轮子
                g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克盖子
                g.fillOval(x + 20, y + 10, 20, 20);//画出圆形盖子
                g.drawLine(x + 30, y + 20, x, y + 20);//画出炮筒
                break;
            default:
                System.out.println("暂时没有处理");
        }
    }

    /*
    编写方法，判断我方坦克是否击中敌人坦克
    我方坦克可以发射多颗子弹，那么在判断我方发射的多颗子弹是否击中敌人坦克时，就需要把我们的
    子弹集合中所有的子弹全部取出遍历，和敌人的坦克一一比对，进行爆炸判断
     */
    public void hitEnemyTank()
    {
        //遍历我们已经发射出的所有子弹
        for (int j = 0; j < hero.shots.size(); j++)
        {
            //取出此时遍历到的这一颗子弹
            Shot shot = hero.shots.get(j);
            //判断当前的子弹是否击中了敌人的坦克
            if (shot != null && shot.isLive == true)  //如果我的子弹存活状态是true
            {
                //遍历所有的敌人坦克
                for (int i = 0; i < enemyTanks.size(); i++)
                {
                    //判断当前取出来的敌人的坦克是否已经被子弹击中？
                    //因为我们并不知道刚打出的这一颗子弹会碰到哪一个敌人坦克，所以只能对敌人坦克不断地进行遍历，
                    //然后不断地调用hitTank()方法，传入此时的子弹对象和敌人坦克对象
                    EnemyTank enemyTank = enemyTanks.get(i);
                    hitTank(shot, enemyTank);
                }
            }
        }
    }

    //编写方法，判断敌人坦克是否击中我的坦克
    public void hitHero()
    {
        //先遍历所有的敌人坦克
        for (int i = 0; i < enemyTanks.size(); i++)
        {
            //接着取出敌人坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //注意，此时得到的敌人坦克会有多颗子弹，所以接着遍历这个敌人坦克对象enemyTank的所有子弹
            for (int j = 0; j < enemyTank.shots.size(); j++)
            {
                //取出这颗子弹
                Shot shot = enemyTank.shots.get(j);
                //然后判断这颗子弹shot是否击中我都坦克hero
                if (hero.isLive == true && shot.isLive == true)
                {
                    hitTank(shot, hero);
                }
            }
        }
    }

    //
    //问题：什么时候开始去判断，我方子弹是否击中敌人坦克？ ——> 在run()方法里面？？？？？？？？？？
    /*
    编写方法，判断子弹是否击中坦克?
    这个方法主要是用来判断一颗子弹是否击中了坦克，与谁的子弹，谁的坦克没有关系，
    就是看有没有坦克被子弹击中而已。
     */
    public void hitTank(Shot shot, Tank tank)
    {
        //判断子弹shot击中坦克Tank
        //判断子弹的x，y坐标，是否在坦克的区域内
        switch (tank.getDirect())
        {
            case 0:
            case 2:
                if (shot.x > tank.getX() && shot.x < tank.getX() + 40
                        && shot.y > tank.getY() && shot.y < tank.getY() + 60)
                //子弹已经落在了方向为上、下的坦克所在的区域
                {
                    //销毁
                    shot.isLive = false;
                    tank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enemyTank从Vector<EnemyTank> enemyTanks中去除
                    enemyTanks.remove(tank);
                    //当我方击毁一个敌人坦克时，就对allEnemyTankNum进行增加
                    //解读, 因为 tank 可以是 Hero 也可以是 EnemyTank,所以要进行类型的判断
                    //如果击中的是敌方坦克
                    if (tank instanceof EnemyTank)
                    {
                        Recorder.addAllEnemyTankNum();
                        Recorder.score += 10;
                        Recorder.enemyTankSize--;
                    }
                    //如果我方坦克被击中
                    if (tank instanceof Hero)
                    {
                        Recorder.heroNum = 0;
                    }
                    //敌人坦克被击中，创建Bomb对象，加入到bombs集合中
                    //当一颗子弹击中敌方坦克时，就把类Bomb的对象bomb加入到集合Vector<Bomb> bombs中去
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    bombs.add(bomb);
                }
                break;

            case 1:
            case 3:
                if (shot.x > tank.getX() && shot.x < tank.getX() + 60
                        && shot.y > tank.getY() && shot.y < tank.getY() + 40)
                //子弹已经落在了方向为左、右的坦克所在的区域
                {
                    //销毁
                    shot.isLive = false;
                    tank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enemyTank从Vector<EnemyTank> enemyTanks中去除
                    enemyTanks.remove(tank);//？？？？？？？？？？？？？？？？
                    //当我方击毁一个敌人坦克时，就对allEnemyTankNum进行增加
                    //解读, 因为 tank 可以是 Hero 也可以是 EnemyTank,所以要进行类型的判断
                    //如果击中的是敌方坦克
                    if (tank instanceof EnemyTank)
                    {
                        Recorder.addAllEnemyTankNum();
                        Recorder.score += 10;
                        Recorder.enemyTankSize--;
                    }
                    //如果我方坦克被击中
                    if (tank instanceof Hero)
                    {
                        Recorder.heroNum = 0;
                    }
                    //敌人坦克被击中，创建Bomb对象，加入到bombs集合中
                    //当一颗子弹击中敌方坦克时，就把类Bomb的对象bomb加入到集合Vector<Bomb> bombs中去
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    bombs.add(bomb);
                }
                break;
        }
    }



    //以下方法是对操作者按键，调用对应的方法
    @Override
    public void keyTyped(KeyEvent e)
    {

    }

    //处理 wdsa键按下的情况
    @Override
    public void keyPressed(KeyEvent e)
    {
        //在java中，会给每一个键，分配一个值(int)
        if (e.getKeyCode() == KeyEvent.VK_W) //如果按下的是 W键
        {
            //改变坦克为向上
            hero.setDirect(0);
            /**
             * 控制我方坦克在限定的范围内移动，也就是添加if()语句，控制我方坦克的
             * 初始关键点x，y，不要让其超出窗口大小this.setSize(1000,750)，
             * 以下同理
             */
            if (hero.getY() > 0 && hero.isTouch() == false)
            {
                hero.moveUp();
            }

        }

        else if (e.getKeyCode() == KeyEvent.VK_D) //如果按下的是 D键
        {
            //改变坦克为向右
            hero.setDirect(1);

            if (hero.getX() + 60 < 1500 && hero.isTouch() == false)
            {
                hero.moveRight();
            }

        }

        else if (e.getKeyCode() == KeyEvent.VK_S) //如果按下的是 S键
        {
            //改变坦克为向下
            hero.setDirect(2);

            if (hero.getY() + 60 < 1250 && hero.isTouch() == false)
            {
                hero.moveDown();
            }

        }

        else if (e.getKeyCode() == KeyEvent.VK_A) //如果按下的是 A键
        {
            //改变坦克为向左
            hero.setDirect(3);

            if (hero.getX() > 0 && hero.isTouch() == false)
            {
                hero.moveLeft();
            }

        }


        //如果用户按下 J键，就发射子弹
        if (e.getKeyCode() == KeyEvent.VK_J)
        {
            //这种情况是先判断前一个子弹线程是否已经销毁，如果销毁了，才能发射新子弹，
            //否则就不能，而且一次只能发射一颗子弹
//            if (hero.shot == null || hero.shot.isLive == false)  //短路或 ||
//            {
//                hero.shotEnemyTank();
//            }

            //现在的这种情况是可以发射多颗子弹
            hero.shotEnemyTank();//这个方法是把子弹打出去，与方法hitEnemyTank()不一样
        }

        //面板重绘
        this.repaint();
    }


    @Override
    public void keyReleased(KeyEvent e)
    {

    }

    @Override
    public void run()  //每间隔40ms，进行重绘区域，让子弹看起来在移动，同时为了让
                       //坦克爆炸的效果更具体，间隔时间不能太小
    {
        while (true) //无限循环
        {
            try
            {
                Thread.sleep(45);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            //判断我方坦克是否击中敌人坦克
            hitEnemyTank();
            //判断敌人坦克是否击中我方坦克
            hitHero();
            //重新绘制
            this.repaint();
        }
    }

}



